// 蜂窝蜜造平台生成代码，如手工更改，请添加到 .beeignore 忽略生成

package com.fowo.api.model.tmp.storage.fee.month;

import com.fowo.api.common.annotaion.DataObjectType;
import com.fowo.api.common.meta.MetaDataObject;
import com.fowo.api.common.meta.MetaDataObjects;
import com.fowo.api.common.model.PageSearch;
import com.fowo.api.common.mybatis.helper.PageSearchHelper;
import com.fowo.api.common.util.ListUtils;
import com.fowo.api.entity.TmpStorageFeeMonth;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import lombok.Getter;
import lombok.Setter;
import org.springframework.format.annotation.DateTimeFormat;

@DataObjectType(TmpStorageFeeMonth.class)
@Setter
@Getter
public class TmpStorageFeeMonthSearchParamPo extends PageSearch {

  private static MetaDataObject metaDataObject;

  @Override
  public void applySqlSegments() {
    if (metaDataObject == null) {
      metaDataObject =
        ListUtils.find(
          MetaDataObjects.getObjects(),
          o -> "TmpStorageFeeMonth".equals(o.getName())
        );
    }
    PageSearchHelper.fillSqlSegments(this, metaDataObject);
  }

  @Override
  public void initFinal() {
    super.initFinal();
    applySqlSegments();
  }

  /**
   * 获取关联字段的查询表别名信息
   */
  @Override
  public Map<String, String> getJoinFieldTableAliasMap() {
    Map<String, String> map = new HashMap<>();
    return map;
  }

  @Override
  public Map<String, OptionalJoinField> getOptionalJoinFields() {
    Map<String, OptionalJoinField> map = new HashMap<>();

    return map;
  }

  /**
   * 编号
   */
  private Long id;

  /**
   * 最小编号
   */
  private Long idMin;

  /**
   * 最大编号
   */
  private Long idMax;

  /**
   * 编号 比较(eq)
   */
  private Long idEq;
  /**
   * 编号 比较(neq)
   */
  private Long idNeq;
  /**
   * 编号 比较(gt)
   */
  private Long idGt;
  /**
   * 编号 比较(gte)
   */
  private Long idGte;
  /**
   * 编号 比较(lt)
   */
  private Long idLt;
  /**
   * 编号 比较(lte)
   */
  private Long idLte;
  /**
   * 编号 比较(contains)
   */
  private Long idContains;
  /**
   * 编号 比较(notcontains)
   */
  private Long idNotcontains;
  /**
   * 编号 比较(startswith)
   */
  private Long idStartswith;
  /**
   * 编号 比较(endswith)
   */
  private Long idEndswith;
  /**
   * 编号 比较(isnull)
   */
  private Boolean idIsnull;
  /**
   * 编号 比较(isnotnull)
   */
  private Boolean idIsnotnull;

  /**
   * 最早创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeStart;

  /**
   * 最晚创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeEnd;

  /**
   * 创建时间 比较(eq)
   */
  private Date createTimeEq;
  /**
   * 创建时间 比较(neq)
   */
  private Date createTimeNeq;
  /**
   * 创建时间 比较(gt)
   */
  private Date createTimeGt;
  /**
   * 创建时间 比较(gte)
   */
  private Date createTimeGte;
  /**
   * 创建时间 比较(lt)
   */
  private Date createTimeLt;
  /**
   * 创建时间 比较(lte)
   */
  private Date createTimeLte;
  /**
   * 创建时间 比较(contains)
   */
  private Date createTimeContains;
  /**
   * 创建时间 比较(notcontains)
   */
  private Date createTimeNotcontains;
  /**
   * 创建时间 比较(startswith)
   */
  private Date createTimeStartswith;
  /**
   * 创建时间 比较(endswith)
   */
  private Date createTimeEndswith;
  /**
   * 创建时间 比较(isnull)
   */
  private Boolean createTimeIsnull;
  /**
   * 创建时间 比较(isnotnull)
   */
  private Boolean createTimeIsnotnull;

  /**
   * 创建人
   */
  private Long createUser;

  /**
   * 最小创建人
   */
  private Long createUserMin;

  /**
   * 最大创建人
   */
  private Long createUserMax;

  /**
   * 创建人 比较(eq)
   */
  private Long createUserEq;
  /**
   * 创建人 比较(neq)
   */
  private Long createUserNeq;
  /**
   * 创建人 比较(gt)
   */
  private Long createUserGt;
  /**
   * 创建人 比较(gte)
   */
  private Long createUserGte;
  /**
   * 创建人 比较(lt)
   */
  private Long createUserLt;
  /**
   * 创建人 比较(lte)
   */
  private Long createUserLte;
  /**
   * 创建人 比较(contains)
   */
  private Long createUserContains;
  /**
   * 创建人 比较(notcontains)
   */
  private Long createUserNotcontains;
  /**
   * 创建人 比较(startswith)
   */
  private Long createUserStartswith;
  /**
   * 创建人 比较(endswith)
   */
  private Long createUserEndswith;
  /**
   * 创建人 比较(isnull)
   */
  private Boolean createUserIsnull;
  /**
   * 创建人 比较(isnotnull)
   */
  private Boolean createUserIsnotnull;

  /**
   * 最早更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeStart;

  /**
   * 最晚更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeEnd;

  /**
   * 更新时间 比较(eq)
   */
  private Date lastUpdateTimeEq;
  /**
   * 更新时间 比较(neq)
   */
  private Date lastUpdateTimeNeq;
  /**
   * 更新时间 比较(gt)
   */
  private Date lastUpdateTimeGt;
  /**
   * 更新时间 比较(gte)
   */
  private Date lastUpdateTimeGte;
  /**
   * 更新时间 比较(lt)
   */
  private Date lastUpdateTimeLt;
  /**
   * 更新时间 比较(lte)
   */
  private Date lastUpdateTimeLte;
  /**
   * 更新时间 比较(contains)
   */
  private Date lastUpdateTimeContains;
  /**
   * 更新时间 比较(notcontains)
   */
  private Date lastUpdateTimeNotcontains;
  /**
   * 更新时间 比较(startswith)
   */
  private Date lastUpdateTimeStartswith;
  /**
   * 更新时间 比较(endswith)
   */
  private Date lastUpdateTimeEndswith;
  /**
   * 更新时间 比较(isnull)
   */
  private Boolean lastUpdateTimeIsnull;
  /**
   * 更新时间 比较(isnotnull)
   */
  private Boolean lastUpdateTimeIsnotnull;

  /**
   * 更新人
   */
  private Long lastUpdateUser;

  /**
   * 最小更新人
   */
  private Long lastUpdateUserMin;

  /**
   * 最大更新人
   */
  private Long lastUpdateUserMax;

  /**
   * 更新人 比较(eq)
   */
  private Long lastUpdateUserEq;
  /**
   * 更新人 比较(neq)
   */
  private Long lastUpdateUserNeq;
  /**
   * 更新人 比较(gt)
   */
  private Long lastUpdateUserGt;
  /**
   * 更新人 比较(gte)
   */
  private Long lastUpdateUserGte;
  /**
   * 更新人 比较(lt)
   */
  private Long lastUpdateUserLt;
  /**
   * 更新人 比较(lte)
   */
  private Long lastUpdateUserLte;
  /**
   * 更新人 比较(contains)
   */
  private Long lastUpdateUserContains;
  /**
   * 更新人 比较(notcontains)
   */
  private Long lastUpdateUserNotcontains;
  /**
   * 更新人 比较(startswith)
   */
  private Long lastUpdateUserStartswith;
  /**
   * 更新人 比较(endswith)
   */
  private Long lastUpdateUserEndswith;
  /**
   * 更新人 比较(isnull)
   */
  private Boolean lastUpdateUserIsnull;
  /**
   * 更新人 比较(isnotnull)
   */
  private Boolean lastUpdateUserIsnotnull;

  /**
   * 店铺id
   */
  private Long sid;

  /**
   * 最小店铺id
   */
  private Long sidMin;

  /**
   * 最大店铺id
   */
  private Long sidMax;

  /**
   * 店铺id 比较(eq)
   */
  private Long sidEq;
  /**
   * 店铺id 比较(neq)
   */
  private Long sidNeq;
  /**
   * 店铺id 比较(gt)
   */
  private Long sidGt;
  /**
   * 店铺id 比较(gte)
   */
  private Long sidGte;
  /**
   * 店铺id 比较(lt)
   */
  private Long sidLt;
  /**
   * 店铺id 比较(lte)
   */
  private Long sidLte;
  /**
   * 店铺id 比较(contains)
   */
  private Long sidContains;
  /**
   * 店铺id 比较(notcontains)
   */
  private Long sidNotcontains;
  /**
   * 店铺id 比较(startswith)
   */
  private Long sidStartswith;
  /**
   * 店铺id 比较(endswith)
   */
  private Long sidEndswith;
  /**
   * 店铺id 比较(isnull)
   */
  private Boolean sidIsnull;
  /**
   * 店铺id 比较(isnotnull)
   */
  private Boolean sidIsnotnull;

  /**
   * ASIN(模糊搜索)
   */
  private String asin;

  /**
   * ASIN 比较(eq)
   */
  private String asinEq;
  /**
   * ASIN 比较(neq)
   */
  private String asinNeq;
  /**
   * ASIN 比较(gt)
   */
  private String asinGt;
  /**
   * ASIN 比较(gte)
   */
  private String asinGte;
  /**
   * ASIN 比较(lt)
   */
  private String asinLt;
  /**
   * ASIN 比较(lte)
   */
  private String asinLte;
  /**
   * ASIN 比较(contains)
   */
  private String asinContains;
  /**
   * ASIN 比较(notcontains)
   */
  private String asinNotcontains;
  /**
   * ASIN 比较(startswith)
   */
  private String asinStartswith;
  /**
   * ASIN 比较(endswith)
   */
  private String asinEndswith;
  /**
   * ASIN 比较(isnull)
   */
  private Boolean asinIsnull;
  /**
   * ASIN 比较(isnotnull)
   */
  private Boolean asinIsnotnull;

  /**
   * ASIN(精确搜索)
   */
  private List<String> asinInList;

  /**
   * FNSKU(模糊搜索)
   */
  private String fnsku;

  /**
   * FNSKU 比较(eq)
   */
  private String fnskuEq;
  /**
   * FNSKU 比较(neq)
   */
  private String fnskuNeq;
  /**
   * FNSKU 比较(gt)
   */
  private String fnskuGt;
  /**
   * FNSKU 比较(gte)
   */
  private String fnskuGte;
  /**
   * FNSKU 比较(lt)
   */
  private String fnskuLt;
  /**
   * FNSKU 比较(lte)
   */
  private String fnskuLte;
  /**
   * FNSKU 比较(contains)
   */
  private String fnskuContains;
  /**
   * FNSKU 比较(notcontains)
   */
  private String fnskuNotcontains;
  /**
   * FNSKU 比较(startswith)
   */
  private String fnskuStartswith;
  /**
   * FNSKU 比较(endswith)
   */
  private String fnskuEndswith;
  /**
   * FNSKU 比较(isnull)
   */
  private Boolean fnskuIsnull;
  /**
   * FNSKU 比较(isnotnull)
   */
  private Boolean fnskuIsnotnull;

  /**
   * FNSKU(精确搜索)
   */
  private List<String> fnskuInList;

  /**
   * 标题(模糊搜索)
   */
  private String productName;

  /**
   * 标题 比较(eq)
   */
  private String productNameEq;
  /**
   * 标题 比较(neq)
   */
  private String productNameNeq;
  /**
   * 标题 比较(gt)
   */
  private String productNameGt;
  /**
   * 标题 比较(gte)
   */
  private String productNameGte;
  /**
   * 标题 比较(lt)
   */
  private String productNameLt;
  /**
   * 标题 比较(lte)
   */
  private String productNameLte;
  /**
   * 标题 比较(contains)
   */
  private String productNameContains;
  /**
   * 标题 比较(notcontains)
   */
  private String productNameNotcontains;
  /**
   * 标题 比较(startswith)
   */
  private String productNameStartswith;
  /**
   * 标题 比较(endswith)
   */
  private String productNameEndswith;
  /**
   * 标题 比较(isnull)
   */
  private Boolean productNameIsnull;
  /**
   * 标题 比较(isnotnull)
   */
  private Boolean productNameIsnotnull;

  /**
   * 标题(精确搜索)
   */
  private List<String> productNameInList;

  /**
   * 仓库编号(模糊搜索)
   */
  private String fulfillmentCenter;

  /**
   * 仓库编号 比较(eq)
   */
  private String fulfillmentCenterEq;
  /**
   * 仓库编号 比较(neq)
   */
  private String fulfillmentCenterNeq;
  /**
   * 仓库编号 比较(gt)
   */
  private String fulfillmentCenterGt;
  /**
   * 仓库编号 比较(gte)
   */
  private String fulfillmentCenterGte;
  /**
   * 仓库编号 比较(lt)
   */
  private String fulfillmentCenterLt;
  /**
   * 仓库编号 比较(lte)
   */
  private String fulfillmentCenterLte;
  /**
   * 仓库编号 比较(contains)
   */
  private String fulfillmentCenterContains;
  /**
   * 仓库编号 比较(notcontains)
   */
  private String fulfillmentCenterNotcontains;
  /**
   * 仓库编号 比较(startswith)
   */
  private String fulfillmentCenterStartswith;
  /**
   * 仓库编号 比较(endswith)
   */
  private String fulfillmentCenterEndswith;
  /**
   * 仓库编号 比较(isnull)
   */
  private Boolean fulfillmentCenterIsnull;
  /**
   * 仓库编号 比较(isnotnull)
   */
  private Boolean fulfillmentCenterIsnotnull;

  /**
   * 仓库编号(精确搜索)
   */
  private List<String> fulfillmentCenterInList;

  /**
   * 国家代码(模糊搜索)
   */
  private String countryCode;

  /**
   * 国家代码 比较(eq)
   */
  private String countryCodeEq;
  /**
   * 国家代码 比较(neq)
   */
  private String countryCodeNeq;
  /**
   * 国家代码 比较(gt)
   */
  private String countryCodeGt;
  /**
   * 国家代码 比较(gte)
   */
  private String countryCodeGte;
  /**
   * 国家代码 比较(lt)
   */
  private String countryCodeLt;
  /**
   * 国家代码 比较(lte)
   */
  private String countryCodeLte;
  /**
   * 国家代码 比较(contains)
   */
  private String countryCodeContains;
  /**
   * 国家代码 比较(notcontains)
   */
  private String countryCodeNotcontains;
  /**
   * 国家代码 比较(startswith)
   */
  private String countryCodeStartswith;
  /**
   * 国家代码 比较(endswith)
   */
  private String countryCodeEndswith;
  /**
   * 国家代码 比较(isnull)
   */
  private Boolean countryCodeIsnull;
  /**
   * 国家代码 比较(isnotnull)
   */
  private Boolean countryCodeIsnotnull;

  /**
   * 国家代码(精确搜索)
   */
  private List<String> countryCodeInList;

  /**
   * 长边(模糊搜索)
   */
  private String longestSide;

  /**
   * 长边 比较(eq)
   */
  private String longestSideEq;
  /**
   * 长边 比较(neq)
   */
  private String longestSideNeq;
  /**
   * 长边 比较(gt)
   */
  private String longestSideGt;
  /**
   * 长边 比较(gte)
   */
  private String longestSideGte;
  /**
   * 长边 比较(lt)
   */
  private String longestSideLt;
  /**
   * 长边 比较(lte)
   */
  private String longestSideLte;
  /**
   * 长边 比较(contains)
   */
  private String longestSideContains;
  /**
   * 长边 比较(notcontains)
   */
  private String longestSideNotcontains;
  /**
   * 长边 比较(startswith)
   */
  private String longestSideStartswith;
  /**
   * 长边 比较(endswith)
   */
  private String longestSideEndswith;
  /**
   * 长边 比较(isnull)
   */
  private Boolean longestSideIsnull;
  /**
   * 长边 比较(isnotnull)
   */
  private Boolean longestSideIsnotnull;

  /**
   * 长边(精确搜索)
   */
  private List<String> longestSideInList;

  /**
   * 中间边(模糊搜索)
   */
  private String medianSide;

  /**
   * 中间边 比较(eq)
   */
  private String medianSideEq;
  /**
   * 中间边 比较(neq)
   */
  private String medianSideNeq;
  /**
   * 中间边 比较(gt)
   */
  private String medianSideGt;
  /**
   * 中间边 比较(gte)
   */
  private String medianSideGte;
  /**
   * 中间边 比较(lt)
   */
  private String medianSideLt;
  /**
   * 中间边 比较(lte)
   */
  private String medianSideLte;
  /**
   * 中间边 比较(contains)
   */
  private String medianSideContains;
  /**
   * 中间边 比较(notcontains)
   */
  private String medianSideNotcontains;
  /**
   * 中间边 比较(startswith)
   */
  private String medianSideStartswith;
  /**
   * 中间边 比较(endswith)
   */
  private String medianSideEndswith;
  /**
   * 中间边 比较(isnull)
   */
  private Boolean medianSideIsnull;
  /**
   * 中间边 比较(isnotnull)
   */
  private Boolean medianSideIsnotnull;

  /**
   * 中间边(精确搜索)
   */
  private List<String> medianSideInList;

  /**
   * 短边(模糊搜索)
   */
  private String shortestSide;

  /**
   * 短边 比较(eq)
   */
  private String shortestSideEq;
  /**
   * 短边 比较(neq)
   */
  private String shortestSideNeq;
  /**
   * 短边 比较(gt)
   */
  private String shortestSideGt;
  /**
   * 短边 比较(gte)
   */
  private String shortestSideGte;
  /**
   * 短边 比较(lt)
   */
  private String shortestSideLt;
  /**
   * 短边 比较(lte)
   */
  private String shortestSideLte;
  /**
   * 短边 比较(contains)
   */
  private String shortestSideContains;
  /**
   * 短边 比较(notcontains)
   */
  private String shortestSideNotcontains;
  /**
   * 短边 比较(startswith)
   */
  private String shortestSideStartswith;
  /**
   * 短边 比较(endswith)
   */
  private String shortestSideEndswith;
  /**
   * 短边 比较(isnull)
   */
  private Boolean shortestSideIsnull;
  /**
   * 短边 比较(isnotnull)
   */
  private Boolean shortestSideIsnotnull;

  /**
   * 短边(精确搜索)
   */
  private List<String> shortestSideInList;

  /**
   * 长中短边单位(模糊搜索)
   */
  private String measurementUnits;

  /**
   * 长中短边单位 比较(eq)
   */
  private String measurementUnitsEq;
  /**
   * 长中短边单位 比较(neq)
   */
  private String measurementUnitsNeq;
  /**
   * 长中短边单位 比较(gt)
   */
  private String measurementUnitsGt;
  /**
   * 长中短边单位 比较(gte)
   */
  private String measurementUnitsGte;
  /**
   * 长中短边单位 比较(lt)
   */
  private String measurementUnitsLt;
  /**
   * 长中短边单位 比较(lte)
   */
  private String measurementUnitsLte;
  /**
   * 长中短边单位 比较(contains)
   */
  private String measurementUnitsContains;
  /**
   * 长中短边单位 比较(notcontains)
   */
  private String measurementUnitsNotcontains;
  /**
   * 长中短边单位 比较(startswith)
   */
  private String measurementUnitsStartswith;
  /**
   * 长中短边单位 比较(endswith)
   */
  private String measurementUnitsEndswith;
  /**
   * 长中短边单位 比较(isnull)
   */
  private Boolean measurementUnitsIsnull;
  /**
   * 长中短边单位 比较(isnotnull)
   */
  private Boolean measurementUnitsIsnotnull;

  /**
   * 长中短边单位(精确搜索)
   */
  private List<String> measurementUnitsInList;

  /**
   * 重量(模糊搜索)
   */
  private String weight;

  /**
   * 重量 比较(eq)
   */
  private String weightEq;
  /**
   * 重量 比较(neq)
   */
  private String weightNeq;
  /**
   * 重量 比较(gt)
   */
  private String weightGt;
  /**
   * 重量 比较(gte)
   */
  private String weightGte;
  /**
   * 重量 比较(lt)
   */
  private String weightLt;
  /**
   * 重量 比较(lte)
   */
  private String weightLte;
  /**
   * 重量 比较(contains)
   */
  private String weightContains;
  /**
   * 重量 比较(notcontains)
   */
  private String weightNotcontains;
  /**
   * 重量 比较(startswith)
   */
  private String weightStartswith;
  /**
   * 重量 比较(endswith)
   */
  private String weightEndswith;
  /**
   * 重量 比较(isnull)
   */
  private Boolean weightIsnull;
  /**
   * 重量 比较(isnotnull)
   */
  private Boolean weightIsnotnull;

  /**
   * 重量(精确搜索)
   */
  private List<String> weightInList;

  /**
   * 重量单位(模糊搜索)
   */
  private String weightUnits;

  /**
   * 重量单位 比较(eq)
   */
  private String weightUnitsEq;
  /**
   * 重量单位 比较(neq)
   */
  private String weightUnitsNeq;
  /**
   * 重量单位 比较(gt)
   */
  private String weightUnitsGt;
  /**
   * 重量单位 比较(gte)
   */
  private String weightUnitsGte;
  /**
   * 重量单位 比较(lt)
   */
  private String weightUnitsLt;
  /**
   * 重量单位 比较(lte)
   */
  private String weightUnitsLte;
  /**
   * 重量单位 比较(contains)
   */
  private String weightUnitsContains;
  /**
   * 重量单位 比较(notcontains)
   */
  private String weightUnitsNotcontains;
  /**
   * 重量单位 比较(startswith)
   */
  private String weightUnitsStartswith;
  /**
   * 重量单位 比较(endswith)
   */
  private String weightUnitsEndswith;
  /**
   * 重量单位 比较(isnull)
   */
  private Boolean weightUnitsIsnull;
  /**
   * 重量单位 比较(isnotnull)
   */
  private Boolean weightUnitsIsnotnull;

  /**
   * 重量单位(精确搜索)
   */
  private List<String> weightUnitsInList;

  /**
   * 体积(模糊搜索)
   */
  private String itemVolume;

  /**
   * 体积 比较(eq)
   */
  private String itemVolumeEq;
  /**
   * 体积 比较(neq)
   */
  private String itemVolumeNeq;
  /**
   * 体积 比较(gt)
   */
  private String itemVolumeGt;
  /**
   * 体积 比较(gte)
   */
  private String itemVolumeGte;
  /**
   * 体积 比较(lt)
   */
  private String itemVolumeLt;
  /**
   * 体积 比较(lte)
   */
  private String itemVolumeLte;
  /**
   * 体积 比较(contains)
   */
  private String itemVolumeContains;
  /**
   * 体积 比较(notcontains)
   */
  private String itemVolumeNotcontains;
  /**
   * 体积 比较(startswith)
   */
  private String itemVolumeStartswith;
  /**
   * 体积 比较(endswith)
   */
  private String itemVolumeEndswith;
  /**
   * 体积 比较(isnull)
   */
  private Boolean itemVolumeIsnull;
  /**
   * 体积 比较(isnotnull)
   */
  private Boolean itemVolumeIsnotnull;

  /**
   * 体积(精确搜索)
   */
  private List<String> itemVolumeInList;

  /**
   * 体积单位(模糊搜索)
   */
  private String volumeUnits;

  /**
   * 体积单位 比较(eq)
   */
  private String volumeUnitsEq;
  /**
   * 体积单位 比较(neq)
   */
  private String volumeUnitsNeq;
  /**
   * 体积单位 比较(gt)
   */
  private String volumeUnitsGt;
  /**
   * 体积单位 比较(gte)
   */
  private String volumeUnitsGte;
  /**
   * 体积单位 比较(lt)
   */
  private String volumeUnitsLt;
  /**
   * 体积单位 比较(lte)
   */
  private String volumeUnitsLte;
  /**
   * 体积单位 比较(contains)
   */
  private String volumeUnitsContains;
  /**
   * 体积单位 比较(notcontains)
   */
  private String volumeUnitsNotcontains;
  /**
   * 体积单位 比较(startswith)
   */
  private String volumeUnitsStartswith;
  /**
   * 体积单位 比较(endswith)
   */
  private String volumeUnitsEndswith;
  /**
   * 体积单位 比较(isnull)
   */
  private Boolean volumeUnitsIsnull;
  /**
   * 体积单位 比较(isnotnull)
   */
  private Boolean volumeUnitsIsnotnull;

  /**
   * 体积单位(精确搜索)
   */
  private List<String> volumeUnitsInList;

  /**
   * 产品标准(模糊搜索)
   */
  private String productSizeTier;

  /**
   * 产品标准 比较(eq)
   */
  private String productSizeTierEq;
  /**
   * 产品标准 比较(neq)
   */
  private String productSizeTierNeq;
  /**
   * 产品标准 比较(gt)
   */
  private String productSizeTierGt;
  /**
   * 产品标准 比较(gte)
   */
  private String productSizeTierGte;
  /**
   * 产品标准 比较(lt)
   */
  private String productSizeTierLt;
  /**
   * 产品标准 比较(lte)
   */
  private String productSizeTierLte;
  /**
   * 产品标准 比较(contains)
   */
  private String productSizeTierContains;
  /**
   * 产品标准 比较(notcontains)
   */
  private String productSizeTierNotcontains;
  /**
   * 产品标准 比较(startswith)
   */
  private String productSizeTierStartswith;
  /**
   * 产品标准 比较(endswith)
   */
  private String productSizeTierEndswith;
  /**
   * 产品标准 比较(isnull)
   */
  private Boolean productSizeTierIsnull;
  /**
   * 产品标准 比较(isnotnull)
   */
  private Boolean productSizeTierIsnotnull;

  /**
   * 产品标准(精确搜索)
   */
  private List<String> productSizeTierInList;

  /**
   * 库存量
   */
  private java.math.BigDecimal averageQuantityOnHand;

  /**
   * 最小库存量
   */
  private java.math.BigDecimal averageQuantityOnHandMin;

  /**
   * 最大库存量
   */
  private java.math.BigDecimal averageQuantityOnHandMax;

  /**
   * 库存量 比较(eq)
   */
  private java.math.BigDecimal averageQuantityOnHandEq;
  /**
   * 库存量 比较(neq)
   */
  private java.math.BigDecimal averageQuantityOnHandNeq;
  /**
   * 库存量 比较(gt)
   */
  private java.math.BigDecimal averageQuantityOnHandGt;
  /**
   * 库存量 比较(gte)
   */
  private java.math.BigDecimal averageQuantityOnHandGte;
  /**
   * 库存量 比较(lt)
   */
  private java.math.BigDecimal averageQuantityOnHandLt;
  /**
   * 库存量 比较(lte)
   */
  private java.math.BigDecimal averageQuantityOnHandLte;
  /**
   * 库存量 比较(contains)
   */
  private java.math.BigDecimal averageQuantityOnHandContains;
  /**
   * 库存量 比较(notcontains)
   */
  private java.math.BigDecimal averageQuantityOnHandNotcontains;
  /**
   * 库存量 比较(startswith)
   */
  private java.math.BigDecimal averageQuantityOnHandStartswith;
  /**
   * 库存量 比较(endswith)
   */
  private java.math.BigDecimal averageQuantityOnHandEndswith;
  /**
   * 库存量 比较(isnull)
   */
  private Boolean averageQuantityOnHandIsnull;
  /**
   * 库存量 比较(isnotnull)
   */
  private Boolean averageQuantityOnHandIsnotnull;

  /**
   * 待移除量
   */
  private java.math.BigDecimal averageQuantityPendingRemoval;

  /**
   * 最小待移除量
   */
  private java.math.BigDecimal averageQuantityPendingRemovalMin;

  /**
   * 最大待移除量
   */
  private java.math.BigDecimal averageQuantityPendingRemovalMax;

  /**
   * 待移除量 比较(eq)
   */
  private java.math.BigDecimal averageQuantityPendingRemovalEq;
  /**
   * 待移除量 比较(neq)
   */
  private java.math.BigDecimal averageQuantityPendingRemovalNeq;
  /**
   * 待移除量 比较(gt)
   */
  private java.math.BigDecimal averageQuantityPendingRemovalGt;
  /**
   * 待移除量 比较(gte)
   */
  private java.math.BigDecimal averageQuantityPendingRemovalGte;
  /**
   * 待移除量 比较(lt)
   */
  private java.math.BigDecimal averageQuantityPendingRemovalLt;
  /**
   * 待移除量 比较(lte)
   */
  private java.math.BigDecimal averageQuantityPendingRemovalLte;
  /**
   * 待移除量 比较(contains)
   */
  private java.math.BigDecimal averageQuantityPendingRemovalContains;
  /**
   * 待移除量 比较(notcontains)
   */
  private java.math.BigDecimal averageQuantityPendingRemovalNotcontains;
  /**
   * 待移除量 比较(startswith)
   */
  private java.math.BigDecimal averageQuantityPendingRemovalStartswith;
  /**
   * 待移除量 比较(endswith)
   */
  private java.math.BigDecimal averageQuantityPendingRemovalEndswith;
  /**
   * 待移除量 比较(isnull)
   */
  private Boolean averageQuantityPendingRemovalIsnull;
  /**
   * 待移除量 比较(isnotnull)
   */
  private Boolean averageQuantityPendingRemovalIsnotnull;

  /**
   * 总体积
   */
  private java.math.BigDecimal estimatedTotalItemVolume;

  /**
   * 最小总体积
   */
  private java.math.BigDecimal estimatedTotalItemVolumeMin;

  /**
   * 最大总体积
   */
  private java.math.BigDecimal estimatedTotalItemVolumeMax;

  /**
   * 总体积 比较(eq)
   */
  private java.math.BigDecimal estimatedTotalItemVolumeEq;
  /**
   * 总体积 比较(neq)
   */
  private java.math.BigDecimal estimatedTotalItemVolumeNeq;
  /**
   * 总体积 比较(gt)
   */
  private java.math.BigDecimal estimatedTotalItemVolumeGt;
  /**
   * 总体积 比较(gte)
   */
  private java.math.BigDecimal estimatedTotalItemVolumeGte;
  /**
   * 总体积 比较(lt)
   */
  private java.math.BigDecimal estimatedTotalItemVolumeLt;
  /**
   * 总体积 比较(lte)
   */
  private java.math.BigDecimal estimatedTotalItemVolumeLte;
  /**
   * 总体积 比较(contains)
   */
  private java.math.BigDecimal estimatedTotalItemVolumeContains;
  /**
   * 总体积 比较(notcontains)
   */
  private java.math.BigDecimal estimatedTotalItemVolumeNotcontains;
  /**
   * 总体积 比较(startswith)
   */
  private java.math.BigDecimal estimatedTotalItemVolumeStartswith;
  /**
   * 总体积 比较(endswith)
   */
  private java.math.BigDecimal estimatedTotalItemVolumeEndswith;
  /**
   * 总体积 比较(isnull)
   */
  private Boolean estimatedTotalItemVolumeIsnull;
  /**
   * 总体积 比较(isnotnull)
   */
  private Boolean estimatedTotalItemVolumeIsnotnull;

  /**
   * 收费月份(模糊搜索)
   */
  private String monthOfCharge;

  /**
   * 收费月份 比较(eq)
   */
  private String monthOfChargeEq;
  /**
   * 收费月份 比较(neq)
   */
  private String monthOfChargeNeq;
  /**
   * 收费月份 比较(gt)
   */
  private String monthOfChargeGt;
  /**
   * 收费月份 比较(gte)
   */
  private String monthOfChargeGte;
  /**
   * 收费月份 比较(lt)
   */
  private String monthOfChargeLt;
  /**
   * 收费月份 比较(lte)
   */
  private String monthOfChargeLte;
  /**
   * 收费月份 比较(contains)
   */
  private String monthOfChargeContains;
  /**
   * 收费月份 比较(notcontains)
   */
  private String monthOfChargeNotcontains;
  /**
   * 收费月份 比较(startswith)
   */
  private String monthOfChargeStartswith;
  /**
   * 收费月份 比较(endswith)
   */
  private String monthOfChargeEndswith;
  /**
   * 收费月份 比较(isnull)
   */
  private Boolean monthOfChargeIsnull;
  /**
   * 收费月份 比较(isnotnull)
   */
  private Boolean monthOfChargeIsnotnull;

  /**
   * 收费月份(精确搜索)
   */
  private List<String> monthOfChargeInList;

  /**
   * 收费标准
   */
  private java.math.BigDecimal storageRate;

  /**
   * 最小收费标准
   */
  private java.math.BigDecimal storageRateMin;

  /**
   * 最大收费标准
   */
  private java.math.BigDecimal storageRateMax;

  /**
   * 收费标准 比较(eq)
   */
  private java.math.BigDecimal storageRateEq;
  /**
   * 收费标准 比较(neq)
   */
  private java.math.BigDecimal storageRateNeq;
  /**
   * 收费标准 比较(gt)
   */
  private java.math.BigDecimal storageRateGt;
  /**
   * 收费标准 比较(gte)
   */
  private java.math.BigDecimal storageRateGte;
  /**
   * 收费标准 比较(lt)
   */
  private java.math.BigDecimal storageRateLt;
  /**
   * 收费标准 比较(lte)
   */
  private java.math.BigDecimal storageRateLte;
  /**
   * 收费标准 比较(contains)
   */
  private java.math.BigDecimal storageRateContains;
  /**
   * 收费标准 比较(notcontains)
   */
  private java.math.BigDecimal storageRateNotcontains;
  /**
   * 收费标准 比较(startswith)
   */
  private java.math.BigDecimal storageRateStartswith;
  /**
   * 收费标准 比较(endswith)
   */
  private java.math.BigDecimal storageRateEndswith;
  /**
   * 收费标准 比较(isnull)
   */
  private Boolean storageRateIsnull;
  /**
   * 收费标准 比较(isnotnull)
   */
  private Boolean storageRateIsnotnull;

  /**
   * 币种(模糊搜索)
   */
  private String currency;

  /**
   * 币种 比较(eq)
   */
  private String currencyEq;
  /**
   * 币种 比较(neq)
   */
  private String currencyNeq;
  /**
   * 币种 比较(gt)
   */
  private String currencyGt;
  /**
   * 币种 比较(gte)
   */
  private String currencyGte;
  /**
   * 币种 比较(lt)
   */
  private String currencyLt;
  /**
   * 币种 比较(lte)
   */
  private String currencyLte;
  /**
   * 币种 比较(contains)
   */
  private String currencyContains;
  /**
   * 币种 比较(notcontains)
   */
  private String currencyNotcontains;
  /**
   * 币种 比较(startswith)
   */
  private String currencyStartswith;
  /**
   * 币种 比较(endswith)
   */
  private String currencyEndswith;
  /**
   * 币种 比较(isnull)
   */
  private Boolean currencyIsnull;
  /**
   * 币种 比较(isnotnull)
   */
  private Boolean currencyIsnotnull;

  /**
   * 币种(精确搜索)
   */
  private List<String> currencyInList;

  /**
   * 预估仓储费
   */
  private java.math.BigDecimal estimatedMonthlyStorageFee;

  /**
   * 最小预估仓储费
   */
  private java.math.BigDecimal estimatedMonthlyStorageFeeMin;

  /**
   * 最大预估仓储费
   */
  private java.math.BigDecimal estimatedMonthlyStorageFeeMax;

  /**
   * 预估仓储费 比较(eq)
   */
  private java.math.BigDecimal estimatedMonthlyStorageFeeEq;
  /**
   * 预估仓储费 比较(neq)
   */
  private java.math.BigDecimal estimatedMonthlyStorageFeeNeq;
  /**
   * 预估仓储费 比较(gt)
   */
  private java.math.BigDecimal estimatedMonthlyStorageFeeGt;
  /**
   * 预估仓储费 比较(gte)
   */
  private java.math.BigDecimal estimatedMonthlyStorageFeeGte;
  /**
   * 预估仓储费 比较(lt)
   */
  private java.math.BigDecimal estimatedMonthlyStorageFeeLt;
  /**
   * 预估仓储费 比较(lte)
   */
  private java.math.BigDecimal estimatedMonthlyStorageFeeLte;
  /**
   * 预估仓储费 比较(contains)
   */
  private java.math.BigDecimal estimatedMonthlyStorageFeeContains;
  /**
   * 预估仓储费 比较(notcontains)
   */
  private java.math.BigDecimal estimatedMonthlyStorageFeeNotcontains;
  /**
   * 预估仓储费 比较(startswith)
   */
  private java.math.BigDecimal estimatedMonthlyStorageFeeStartswith;
  /**
   * 预估仓储费 比较(endswith)
   */
  private java.math.BigDecimal estimatedMonthlyStorageFeeEndswith;
  /**
   * 预估仓储费 比较(isnull)
   */
  private Boolean estimatedMonthlyStorageFeeIsnull;
  /**
   * 预估仓储费 比较(isnotnull)
   */
  private Boolean estimatedMonthlyStorageFeeIsnotnull;

  /**
   * 危险品存放类型(模糊搜索)
   */
  private String dangerousGoodsStorageType;

  /**
   * 危险品存放类型 比较(eq)
   */
  private String dangerousGoodsStorageTypeEq;
  /**
   * 危险品存放类型 比较(neq)
   */
  private String dangerousGoodsStorageTypeNeq;
  /**
   * 危险品存放类型 比较(gt)
   */
  private String dangerousGoodsStorageTypeGt;
  /**
   * 危险品存放类型 比较(gte)
   */
  private String dangerousGoodsStorageTypeGte;
  /**
   * 危险品存放类型 比较(lt)
   */
  private String dangerousGoodsStorageTypeLt;
  /**
   * 危险品存放类型 比较(lte)
   */
  private String dangerousGoodsStorageTypeLte;
  /**
   * 危险品存放类型 比较(contains)
   */
  private String dangerousGoodsStorageTypeContains;
  /**
   * 危险品存放类型 比较(notcontains)
   */
  private String dangerousGoodsStorageTypeNotcontains;
  /**
   * 危险品存放类型 比较(startswith)
   */
  private String dangerousGoodsStorageTypeStartswith;
  /**
   * 危险品存放类型 比较(endswith)
   */
  private String dangerousGoodsStorageTypeEndswith;
  /**
   * 危险品存放类型 比较(isnull)
   */
  private Boolean dangerousGoodsStorageTypeIsnull;
  /**
   * 危险品存放类型 比较(isnotnull)
   */
  private Boolean dangerousGoodsStorageTypeIsnotnull;

  /**
   * 危险品存放类型(精确搜索)
   */
  private List<String> dangerousGoodsStorageTypeInList;

  /**
   * 可享受存货折扣(模糊搜索)
   */
  private String eligibleForInventoryDiscount;

  /**
   * 可享受存货折扣 比较(eq)
   */
  private String eligibleForInventoryDiscountEq;
  /**
   * 可享受存货折扣 比较(neq)
   */
  private String eligibleForInventoryDiscountNeq;
  /**
   * 可享受存货折扣 比较(gt)
   */
  private String eligibleForInventoryDiscountGt;
  /**
   * 可享受存货折扣 比较(gte)
   */
  private String eligibleForInventoryDiscountGte;
  /**
   * 可享受存货折扣 比较(lt)
   */
  private String eligibleForInventoryDiscountLt;
  /**
   * 可享受存货折扣 比较(lte)
   */
  private String eligibleForInventoryDiscountLte;
  /**
   * 可享受存货折扣 比较(contains)
   */
  private String eligibleForInventoryDiscountContains;
  /**
   * 可享受存货折扣 比较(notcontains)
   */
  private String eligibleForInventoryDiscountNotcontains;
  /**
   * 可享受存货折扣 比较(startswith)
   */
  private String eligibleForInventoryDiscountStartswith;
  /**
   * 可享受存货折扣 比较(endswith)
   */
  private String eligibleForInventoryDiscountEndswith;
  /**
   * 可享受存货折扣 比较(isnull)
   */
  private Boolean eligibleForInventoryDiscountIsnull;
  /**
   * 可享受存货折扣 比较(isnotnull)
   */
  private Boolean eligibleForInventoryDiscountIsnotnull;

  /**
   * 可享受存货折扣(精确搜索)
   */
  private List<String> eligibleForInventoryDiscountInList;

  /**
   * 可享受库存折扣(模糊搜索)
   */
  private String qualifiesForInventoryDiscount;

  /**
   * 可享受库存折扣 比较(eq)
   */
  private String qualifiesForInventoryDiscountEq;
  /**
   * 可享受库存折扣 比较(neq)
   */
  private String qualifiesForInventoryDiscountNeq;
  /**
   * 可享受库存折扣 比较(gt)
   */
  private String qualifiesForInventoryDiscountGt;
  /**
   * 可享受库存折扣 比较(gte)
   */
  private String qualifiesForInventoryDiscountGte;
  /**
   * 可享受库存折扣 比较(lt)
   */
  private String qualifiesForInventoryDiscountLt;
  /**
   * 可享受库存折扣 比较(lte)
   */
  private String qualifiesForInventoryDiscountLte;
  /**
   * 可享受库存折扣 比较(contains)
   */
  private String qualifiesForInventoryDiscountContains;
  /**
   * 可享受库存折扣 比较(notcontains)
   */
  private String qualifiesForInventoryDiscountNotcontains;
  /**
   * 可享受库存折扣 比较(startswith)
   */
  private String qualifiesForInventoryDiscountStartswith;
  /**
   * 可享受库存折扣 比较(endswith)
   */
  private String qualifiesForInventoryDiscountEndswith;
  /**
   * 可享受库存折扣 比较(isnull)
   */
  private Boolean qualifiesForInventoryDiscountIsnull;
  /**
   * 可享受库存折扣 比较(isnotnull)
   */
  private Boolean qualifiesForInventoryDiscountIsnotnull;

  /**
   * 可享受库存折扣(精确搜索)
   */
  private List<String> qualifiesForInventoryDiscountInList;

  /**
   * 折扣总额(模糊搜索)
   */
  private String totalIncentiveFeeAmount;

  /**
   * 折扣总额 比较(eq)
   */
  private String totalIncentiveFeeAmountEq;
  /**
   * 折扣总额 比较(neq)
   */
  private String totalIncentiveFeeAmountNeq;
  /**
   * 折扣总额 比较(gt)
   */
  private String totalIncentiveFeeAmountGt;
  /**
   * 折扣总额 比较(gte)
   */
  private String totalIncentiveFeeAmountGte;
  /**
   * 折扣总额 比较(lt)
   */
  private String totalIncentiveFeeAmountLt;
  /**
   * 折扣总额 比较(lte)
   */
  private String totalIncentiveFeeAmountLte;
  /**
   * 折扣总额 比较(contains)
   */
  private String totalIncentiveFeeAmountContains;
  /**
   * 折扣总额 比较(notcontains)
   */
  private String totalIncentiveFeeAmountNotcontains;
  /**
   * 折扣总额 比较(startswith)
   */
  private String totalIncentiveFeeAmountStartswith;
  /**
   * 折扣总额 比较(endswith)
   */
  private String totalIncentiveFeeAmountEndswith;
  /**
   * 折扣总额 比较(isnull)
   */
  private Boolean totalIncentiveFeeAmountIsnull;
  /**
   * 折扣总额 比较(isnotnull)
   */
  private Boolean totalIncentiveFeeAmountIsnotnull;

  /**
   * 折扣总额(精确搜索)
   */
  private List<String> totalIncentiveFeeAmountInList;

  /**
   * 分项激励金额(模糊搜索)
   */
  private String breakdownIncentiveFeeAmount;

  /**
   * 分项激励金额 比较(eq)
   */
  private String breakdownIncentiveFeeAmountEq;
  /**
   * 分项激励金额 比较(neq)
   */
  private String breakdownIncentiveFeeAmountNeq;
  /**
   * 分项激励金额 比较(gt)
   */
  private String breakdownIncentiveFeeAmountGt;
  /**
   * 分项激励金额 比较(gte)
   */
  private String breakdownIncentiveFeeAmountGte;
  /**
   * 分项激励金额 比较(lt)
   */
  private String breakdownIncentiveFeeAmountLt;
  /**
   * 分项激励金额 比较(lte)
   */
  private String breakdownIncentiveFeeAmountLte;
  /**
   * 分项激励金额 比较(contains)
   */
  private String breakdownIncentiveFeeAmountContains;
  /**
   * 分项激励金额 比较(notcontains)
   */
  private String breakdownIncentiveFeeAmountNotcontains;
  /**
   * 分项激励金额 比较(startswith)
   */
  private String breakdownIncentiveFeeAmountStartswith;
  /**
   * 分项激励金额 比较(endswith)
   */
  private String breakdownIncentiveFeeAmountEndswith;
  /**
   * 分项激励金额 比较(isnull)
   */
  private Boolean breakdownIncentiveFeeAmountIsnull;
  /**
   * 分项激励金额 比较(isnotnull)
   */
  private Boolean breakdownIncentiveFeeAmountIsnotnull;

  /**
   * 分项激励金额(精确搜索)
   */
  private List<String> breakdownIncentiveFeeAmountInList;

  /**
   * 客户订单平均数量(模糊搜索)
   */
  private String averageQuantityCustomerOrders;

  /**
   * 客户订单平均数量 比较(eq)
   */
  private String averageQuantityCustomerOrdersEq;
  /**
   * 客户订单平均数量 比较(neq)
   */
  private String averageQuantityCustomerOrdersNeq;
  /**
   * 客户订单平均数量 比较(gt)
   */
  private String averageQuantityCustomerOrdersGt;
  /**
   * 客户订单平均数量 比较(gte)
   */
  private String averageQuantityCustomerOrdersGte;
  /**
   * 客户订单平均数量 比较(lt)
   */
  private String averageQuantityCustomerOrdersLt;
  /**
   * 客户订单平均数量 比较(lte)
   */
  private String averageQuantityCustomerOrdersLte;
  /**
   * 客户订单平均数量 比较(contains)
   */
  private String averageQuantityCustomerOrdersContains;
  /**
   * 客户订单平均数量 比较(notcontains)
   */
  private String averageQuantityCustomerOrdersNotcontains;
  /**
   * 客户订单平均数量 比较(startswith)
   */
  private String averageQuantityCustomerOrdersStartswith;
  /**
   * 客户订单平均数量 比较(endswith)
   */
  private String averageQuantityCustomerOrdersEndswith;
  /**
   * 客户订单平均数量 比较(isnull)
   */
  private Boolean averageQuantityCustomerOrdersIsnull;
  /**
   * 客户订单平均数量 比较(isnotnull)
   */
  private Boolean averageQuantityCustomerOrdersIsnotnull;

  /**
   * 客户订单平均数量(精确搜索)
   */
  private List<String> averageQuantityCustomerOrdersInList;

  /**
   * 是否有 图片
   */
  private Boolean img;

  /**
   * 品名(模糊搜索)
   */
  private String name;

  /**
   * 品名 比较(eq)
   */
  private String nameEq;
  /**
   * 品名 比较(neq)
   */
  private String nameNeq;
  /**
   * 品名 比较(gt)
   */
  private String nameGt;
  /**
   * 品名 比较(gte)
   */
  private String nameGte;
  /**
   * 品名 比较(lt)
   */
  private String nameLt;
  /**
   * 品名 比较(lte)
   */
  private String nameLte;
  /**
   * 品名 比较(contains)
   */
  private String nameContains;
  /**
   * 品名 比较(notcontains)
   */
  private String nameNotcontains;
  /**
   * 品名 比较(startswith)
   */
  private String nameStartswith;
  /**
   * 品名 比较(endswith)
   */
  private String nameEndswith;
  /**
   * 品名 比较(isnull)
   */
  private Boolean nameIsnull;
  /**
   * 品名 比较(isnotnull)
   */
  private Boolean nameIsnotnull;

  /**
   * 品名(精确搜索)
   */
  private List<String> nameInList;

  /**
   * SKU(模糊搜索)
   */
  private String sku;

  /**
   * SKU 比较(eq)
   */
  private String skuEq;
  /**
   * SKU 比较(neq)
   */
  private String skuNeq;
  /**
   * SKU 比较(gt)
   */
  private String skuGt;
  /**
   * SKU 比较(gte)
   */
  private String skuGte;
  /**
   * SKU 比较(lt)
   */
  private String skuLt;
  /**
   * SKU 比较(lte)
   */
  private String skuLte;
  /**
   * SKU 比较(contains)
   */
  private String skuContains;
  /**
   * SKU 比较(notcontains)
   */
  private String skuNotcontains;
  /**
   * SKU 比较(startswith)
   */
  private String skuStartswith;
  /**
   * SKU 比较(endswith)
   */
  private String skuEndswith;
  /**
   * SKU 比较(isnull)
   */
  private Boolean skuIsnull;
  /**
   * SKU 比较(isnotnull)
   */
  private Boolean skuIsnotnull;

  /**
   * SKU(精确搜索)
   */
  private List<String> skuInList;

  /**
   * 国家
   */
  private Long country;

  /**
   * 最小国家
   */
  private Long countryMin;

  /**
   * 最大国家
   */
  private Long countryMax;

  /**
   * 国家 比较(eq)
   */
  private Long countryEq;
  /**
   * 国家 比较(neq)
   */
  private Long countryNeq;
  /**
   * 国家 比较(gt)
   */
  private Long countryGt;
  /**
   * 国家 比较(gte)
   */
  private Long countryGte;
  /**
   * 国家 比较(lt)
   */
  private Long countryLt;
  /**
   * 国家 比较(lte)
   */
  private Long countryLte;
  /**
   * 国家 比较(contains)
   */
  private Long countryContains;
  /**
   * 国家 比较(notcontains)
   */
  private Long countryNotcontains;
  /**
   * 国家 比较(startswith)
   */
  private Long countryStartswith;
  /**
   * 国家 比较(endswith)
   */
  private Long countryEndswith;
  /**
   * 国家 比较(isnull)
   */
  private Boolean countryIsnull;
  /**
   * 国家 比较(isnotnull)
   */
  private Boolean countryIsnotnull;

  /**
   * 表单名称
   */
  private String formName;

  /**
   * 工作流状态
   */
  private Integer wfStatus;
}
